setup/services.py (1)

167-186: ⚠️ Potential issue | 🔴 Critical

Move the uvicorn launch logic from start_services() into start_backend().

The start_backend() function at lines 167–186 validates inputs but never starts the backend. The actual uvicorn launch code (subprocess.Popen with the uvicorn command) is orphaned at lines 359–385 inside start_services(), where the variables python_exe, host, port, and debug are undefined—they don't exist in that function's scope. This causes a NameError at runtime when start_services() executes.

The backend launch body must be restored to start_backend() after the host validation at line 186, and the orphaned block must be removed from start_services(). Additionally, there is a duplicate definition of start_node_service() at lines 189 and 388—remove one.

Suggested fix

 def start_backend(host: str, port: int = 8000, debug: bool = False):
     """Start the Python backend server.
 
     Args:
         host: The host to bind to.
         port: The port to bind to (default: 8000).
         debug: Enable debug mode.
     """
     python_exe = get_python_executable()
 
     # Validate the python executable path to prevent command injection
     if not validate_path_safety(python_exe):
         logger.error(f"Unsafe Python executable path: {python_exe}")
         return
 
     # Sanitize host parameter to prevent command injection
     import re
     if not re.match(r'^[a-zA-Z0-9.-]+$', host):
         logger.error(f'Invalid host parameter: {host}')
         return None
+
+    cmd = [
+        python_exe,
+        "-m",
+        "uvicorn",
+        "src.main:create_app",
+        "--factory",
+        "--host",
+        host,
+        "--port",
+        str(port),
+    ]
+    if debug:
+        cmd.extend(["--reload", "--log-level", "debug"])
+
+    logger.info(f"Starting Python backend on {host}:{port}")
+    env = os.environ.copy()
+    env["PYTHONPATH"] = str(ROOT_DIR)
+
+    try:
+        process = subprocess.Popen(cmd, env=env, cwd=ROOT_DIR)
+        from setup.utils import process_manager
+        process_manager.add_process(process)
+    except Exception as e:
+        logger.error(f"Failed to start backend: {e}")

Remove lines 359–385 from start_services().

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/services.py` around lines 167 - 186, The uvicorn subprocess launch was
left out of start_backend() causing NameError in start_services(); move the
uvicorn launch logic (the subprocess.Popen that builds the uvicorn command using
python_exe, host, port, debug) into start_backend() immediately after the host
validation block, ensuring it uses get_python_executable(),
validate_path_safety(), and the host/port/debug parameters already validated
there; then remove the orphaned uvicorn subprocess block from start_services()
(the block referencing python_exe, host, port, debug) and delete the duplicate
start_node_service() definition (keep only the intended one) so there are no
conflicting or undefined references.

src/backend/python_nlp/smart_filters.py (1)

118-124: ⚠️ Potential issue | 🔴 Critical

Create the parent directory before the first sqlite3.connect().

validate_and_resolve_db_path() resolves the file path but does not create directories. On a clean checkout where data/filters/ does not exist, initialization fails immediately when _init_filter_db() is called during __init__, triggering an OperationalError in _get_db_connection().

🐛 Suggested fix

         self.db_path = str(PathValidator.validate_and_resolve_db_path(db_path, DATA_DIR))
         self.logger = logging.getLogger(__name__)
         self.conn = None
+        if self.db_path != ":memory:":
+            os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
         if self.db_path == ":memory:":

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/backend/python_nlp/smart_filters.py` around lines 118 - 124, The
constructor sets self.db_path from validate_and_resolve_db_path and may call
sqlite3.connect before ensuring the parent directory exists, causing
OperationalError on fresh checkouts; modify __init__ so that if self.db_path is
not ":memory:" you create the parent directory for Path(self.db_path).parent
(parents=True, exist_ok=True) before any sqlite3.connect or before calling
_init_filter_db(), ensuring _get_db_connection() can open the file-backed DB
successfully.

src/core/performance_monitor.py (3)

266-275: ⚠️ Potential issue | 🔴 Critical

Critical: record_metric method is missing from OptimizedPerformanceMonitor.

The class calls self.record_metric() here and in other places (lines 300-302, 320-322), but no record_metric method is defined anywhere in OptimizedPerformanceMonitor. This will raise AttributeError at runtime.

Additionally, the global convenience function at line 432-434 delegates to performance_monitor.record_metric(), and callers like src/main.py:667-672 use this function.

🐛 Proposed fix - Add missing record_metric method

Add the missing method to OptimizedPerformanceMonitor:

def record_metric(
    self,
    name: str,
    value: Union[int, float],
    unit: str,
    tags: Optional[Dict[str, str]] = None,
    sample_rate: float = 1.0,
) -> None:
    """Record a single performance metric."""
    import random
    
    # Apply sampling
    if sample_rate < 1.0 and random.random() > sample_rate:
        return
    
    metric = OptimizedPerformanceMetric(
        name=name,
        value=value,
        unit=unit,
        timestamp=time.time(),
        tags=tags or {},
        sample_rate=sample_rate,
    )
    
    with self._buffer_lock:
        self._metrics_buffer.append(metric)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/core/performance_monitor.py` around lines 266 - 275, Add a missing
record_metric method to OptimizedPerformanceMonitor so calls to
self.record_metric(...) (used in log_performance and elsewhere) don't raise
AttributeError: implement record_metric(self, name, value, unit, tags=None,
sample_rate=1.0) to apply sampling, construct an OptimizedPerformanceMetric with
timestamp=time.time(), sample_rate and provided tags, then append it to the
monitor's buffer inside the existing _buffer_lock (i.e.,
self._metrics_buffer.append(metric) within a with self._buffer_lock block) so
global convenience functions and callers delegating to
performance_monitor.record_metric() work correctly.

---

182-190: ⚠️ Potential issue | 🟡 Minor

Move imports to top of file to fix E402 lint errors.

Pipeline is failing due to module-level imports not at top of file. Move these imports (atexit, defaultdict, deque, asdict, dataclass, Path, and re-imported types) to the top with other imports.

Also, line 190 redundantly reassigns logger which is already defined at line 25.

🔧 Proposed fix

Move the following imports to the top of the file (around lines 13-24):

 import asyncio
+import atexit
 import json
 import logging
 import threading
 import time
-from dataclasses import dataclass
+from collections import defaultdict, deque
+from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from functools import wraps
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union

 import psutil

Then remove lines 182-190:

-import atexit
-
-# Enhanced performance monitoring system with additional features
-from collections import defaultdict, deque
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any, Dict, Optional, Union
-
-logger = logging.getLogger(__name__)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/core/performance_monitor.py` around lines 182 - 190, Move the
module-level imports atexit, collections.defaultdict, collections.deque,
dataclasses.asdict, dataclasses.dataclass, pathlib.Path and the typing names
(Any, Dict, Optional, Union) up into the top import block with the other imports
to resolve E402; then remove the redundant re-assignment of the module logger
(the duplicate logger = logging.getLogger(__name__) near the bottom) so only the
original logger variable (defined earlier) remains. Ensure you update any import
lines to import the exact symbols (atexit, defaultdict, deque, asdict,
dataclass, Path, Any, Dict, Optional, Union) and delete the later duplicate
logger assignment to avoid shadowing.

---

313-324: ⚠️ Potential issue | 🔴 Critical

Bug: TimerContext cannot access outer class's record_metric.

self.record_metric on line 320 refers to TimerContext.record_metric, which doesn't exist. The nested class needs a reference to the outer OptimizedPerformanceMonitor instance.

🐛 Proposed fix

             # Used as `@time_function`("name") or with time_function("name"):
             class TimerContext:
+                def __init__(ctx, monitor):
+                    ctx.monitor = monitor
+
                 def __enter__(self):
                     self.start_time = time.perf_counter()
                     return self

                 def __exit__(self, exc_type, exc_val, exc_tb):
                     duration = (time.perf_counter() - self.start_time) * 1000
-                    self.record_metric(
+                    self.monitor.record_metric(
                         name=name, value=duration, unit="ms", tags=tags, sample_rate=sample_rate
                     )

-            return TimerContext()
+            return TimerContext(self)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/core/performance_monitor.py` around lines 313 - 324, TimerContext,
defined inside OptimizedPerformanceMonitor, tries to call self.record_metric but
self there is a TimerContext instance without that method; capture the outer
OptimizedPerformanceMonitor instance and call its record_metric instead. Fix by
capturing the outer self (e.g., outer_self = self) before defining TimerContext
and either (a) store outer_self on the TimerContext instance (via an __init__
that accepts outer_self) and call outer_self.record_metric(...) in __exit__, or
(b) have __exit__ reference the closure variable outer_self.record_metric(...);
ensure you pass name, tags, and sample_rate through unchanged.

setup/launch.py (5)

529-640: ⚠️ Potential issue | 🔴 Critical

Remove duplicate service function definitions (F811 errors).

Lines 529-640 redefine functions that are already imported from setup.services and setup.environment:

• start_backend (line 529) - imported from line 23
• start_node_service (line 549) - imported from line 23
• start_gradio_ui (line 573) - imported from line 23
• handle_setup (line 595) - imported from line 27
• prepare_environment (line 617) - imported from line 27
• start_services (line 630) - imported from line 23

Additionally, prepare_environment (line 621) calls activate_conda_env() which is never imported, causing NameError.

Recommendation: Remove these local redefinitions and rely on the imported implementations. If local customization is needed, either:

1. Don't import these functions and keep local definitions with all dependencies properly imported
2. Import them under different names if both versions are needed

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/launch.py` around lines 529 - 640, The file defines local functions
start_backend, start_node_service, start_gradio_ui, handle_setup,
prepare_environment, and start_services that duplicate imports from
setup.services and setup.environment (F811) and also calls activate_conda_env
which isn’t imported; remove these local redefinitions and use the imported
implementations instead, or if you need customized behavior, stop importing the
originals and import any missing helpers (e.g., activate_conda_env) and rename
imports to avoid name collisions (e.g., from setup.services import start_backend
as svc_start_backend) so there are no duplicate symbols and all referenced
functions are properly imported.

---

676-723: ⚠️ Potential issue | 🔴 Critical

Remove duplicate print_system_info definition and fix undefined is_conda_available.

print_system_info (line 676) is already imported from setup.utils (line 29). The local redefinition causes F811 error.

Additionally, line 703 calls is_conda_available() which is never imported, causing NameError at runtime.

Recommendation: Remove the local print_system_info function (lines 676-723) and use the imported version. If the local version is preferred, import is_conda_available from setup.environment.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/launch.py` around lines 676 - 723, The local redefinition of
print_system_info conflicts with the imported version from setup.utils and
is_conda_available is undefined; remove the entire local print_system_info
function and rely on the imported setup.utils.print_system_info, or if you
prefer keeping this local implementation, delete the import and ensure you
import is_conda_available from setup.environment (or the correct module) and any
other helpers used (e.g., get_venv_executable, check_node_npm_installed) so the
function has all dependencies resolved; update imports accordingly and run
linters to confirm the F811 and NameError are fixed.

---

726-838: ⚠️ Potential issue | 🟠 Major

Remove duplicate main() function definition.

Two main() functions are defined:

1. Lines 726-838: First definition (dead code, shadowed by second)
2. Lines 929-982: Second definition (the one that actually runs)

The first main() function will never execute because Python uses the last definition. Delete lines 726-838 to remove dead code and fix the F811 error.

Also applies to: 929-982

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/launch.py` around lines 726 - 838, There are two definitions of main();
remove the earlier duplicate function so only the intended main() remains (the
one that delegates to _execute_command and _handle_legacy_args). Delete the
dead/duplicated main() block that contains the argparse setup shadowed by the
later definition, and verify references to COMMAND_PATTERN_AVAILABLE,
initialize_all_services, and get_container remain valid elsewhere (or migrate
their initialization into the retained main() if needed) before running tests.

---

90-199: ⚠️ Potential issue | 🔴 Critical

Remove duplicate function definitions causing F811 errors and fix undefined is_wsl.

Lines 90-199 contain local redefinitions of functions that are already imported from setup.validation and setup.environment:

• setup_wsl_environment (line 90) - imported from line 27
• check_wsl_requirements (line 112) - imported from line 27
• check_python_version (line 128) - imported from line 19
• check_required_components (line 145) - imported from line 19
• validate_environment (line 188) - imported from line 20

Additionally, the local setup_wsl_environment and check_wsl_requirements call is_wsl() (lines 92, 114) which is never defined or imported, causing NameError at runtime.

Recommendation: Delete lines 90-199 entirely and rely on the imported implementations from setup.validation and setup.environment.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/launch.py` around lines 90 - 199, There are duplicate local definitions
of setup_wsl_environment, check_wsl_requirements, check_python_version,
check_required_components, and validate_environment which shadow the imported
implementations and reference an undefined is_wsl; remove the entire local block
(the duplicated functions) so the module uses the already-imported functions
from setup.validation and setup.environment, and if any remaining code still
calls is_wsl ensure you import is_wsl from setup.environment (or remove those
calls) so no NameError occurs.

---

1-46: ⚠️ Potential issue | 🔴 Critical

This file has critical merge artifacts that will cause runtime failures.

The file structure indicates incomplete merge conflict resolution. Functions are both imported AND redefined locally, and several undefined names (get_python_executable, is_wsl, COMMAND_PATTERN_AVAILABLE) will cause NameError at runtime.

Recommended approach to fix all issues:

1. Remove all local redefinitions (lines 90–199, 529–640, 676–723, 726–838) and rely on imported implementations
2. Add missing imports:
   • get_python_executable from setup.services
   • is_wsl from setup.environment
3. Initialize COMMAND_PATTERN_AVAILABLE in the try/except block (lines 52–59) — should be COMMAND_PATTERN_AVAILABLE = (get_command_factory is not None)
4. Remove the duplicate main() function (line 929 or 726, keep only one)
5. Remove unused imports (validate_services, atexit, threading)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@setup/launch.py` around lines 1 - 46, The file contains unresolved merge
artifacts: remove the locally redefined implementations and keep the imported
ones (drop the duplicate local definitions spanning the indicated blocks and the
duplicate main() function, retaining a single main()), add missing imports
get_python_executable from setup.services and is_wsl from setup.environment,
initialize COMMAND_PATTERN_AVAILABLE in the try/except that checks
get_command_factory as COMMAND_PATTERN_AVAILABLE = (get_command_factory is not
None), and remove unused imports validate_services, atexit, and threading;
ensure references to get_python_executable, is_wsl, get_command_factory, and
main() resolve to the single imported/kept definitions.